home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr53 / frasrc18.zip / ROTATE.C < prev    next >
C/C++ Source or Header  |  1992-07-10  |  15KB  |  464 lines
  1. /*
  2.     rotate.c - Routines that manipulate the Video DAC on VGA Adapters
  3.     This module is linked as an overlay, use ENTER_OVLY and EXIT_OVLY.
  4. */
  5.  
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <time.h>
  10. #include "fractint.h"
  11. #include "helpdefs.h"
  12. #include "prototyp.h"
  13.  
  14. /* routines in this module    */
  15.  
  16. static void pauserotate(void);
  17. static void set_palette(),set_palette2(),set_palette3();
  18.  
  19. extern char temp1[];
  20.  
  21. extern    int    colors;         /* maximum colors available */
  22.  
  23. extern BYTE dacbox[256][3];    /* Video-DAC (filled in by SETVIDEO) */
  24. extern    int    gotrealdac;        /* dacbox valid? */
  25. extern BYTE olddacbox[256][3];
  26. extern int    daclearn, daccount;    /* used by the color-cyclers */
  27. extern int    reallyega;        /* == 0 if it's really an EGA */
  28. extern int    rotate_lo,rotate_hi;    /* range of colors to cycle */
  29. extern int    colorstate; /* comments in cmdfiles */
  30. extern char    colorfile[];
  31. extern int    dotmode;
  32.  
  33. static int paused;            /* rotate-is-paused flag */
  34.  
  35. static BYTE Red[3]    = {63, 0, 0};    /* for shifted-Fkeys */
  36. static BYTE Green[3]  = { 0,63, 0};
  37. static BYTE Blue[3]   = { 0, 0,63};
  38. static BYTE Black[3]  = { 0, 0, 0};
  39. static BYTE White[3]  = {63,63,63};
  40. static BYTE Yellow[3] = {63,63, 0};
  41. static BYTE Brown[3]  = {31,31, 0};
  42.  
  43. char mapmask[13] = {"*.map"};
  44.  
  45.  
  46. void rotate_overlay() { }    /* for restore_active_ovly */
  47.  
  48. void rotate(int direction)    /* rotate-the-palette routine */
  49. {
  50. int  kbdchar, more, last, next;
  51. int fkey, step, fstep, istep, jstep, oldstep;
  52. int incr, fromred, fromblue, fromgreen, tored, toblue, togreen;
  53. int i, changecolor, changedirection;
  54. int oldhelpmode;
  55. int rotate_max,rotate_size;
  56.  
  57. static int fsteps[] = {2,4,8,12,16,24,32,40,54,100}; /* (for Fkeys) */
  58.  
  59.    ENTER_OVLY(OVLY_ROTATE);
  60.  
  61.    if (gotrealdac == 0            /* ??? no DAC to rotate! */
  62.      || colors < 16) {            /* strange things happen in 2x modes */
  63.       buzzer(2);
  64.       EXIT_OVLY;
  65.       return;
  66.       }
  67.  
  68.    oldhelpmode = helpmode;        /* save the old help mode    */
  69.    helpmode = HELPCYCLING;        /* new help mode        */
  70.  
  71.    paused = 0;                /* not paused            */
  72.    fkey = 0;                /* no random coloring        */
  73.    oldstep = step = 1;            /* single-step            */
  74.    fstep = 1;
  75.    changecolor = -1;            /* no color (rgb) to change    */
  76.    changedirection = 0;         /* no color direction to change */
  77.    incr = 999;                /* ready to randomize        */
  78.    srand((unsigned)time(NULL));     /* randomize things        */
  79.  
  80.    if (direction == 0) {        /* firing up in paused mode?    */
  81.       pauserotate();            /* then force a pause        */
  82.       direction = 1;            /* and set a rotate direction    */
  83.       }
  84.  
  85.    rotate_max = (rotate_hi < colors) ? rotate_hi : colors-1;
  86.    rotate_size = rotate_max - rotate_lo + 1;
  87.    last = rotate_max;            /* last box that was filled    */
  88.    next = rotate_lo;            /* next box to be filled    */
  89.    if (direction < 0) {
  90.       last = rotate_lo;
  91.       next = rotate_max;
  92.       }
  93.  
  94.    more = 1;
  95.    while (more) {
  96.       if (dotmode == 11) {
  97.      if (!paused)
  98.         pauserotate();
  99.      }
  100.       else while(!keypressed()) { /* rotate until key hit, at least once so step=oldstep ok */
  101.      if (fkey > 0) {        /* randomizing is on */
  102.         for (istep = 0; istep < step; istep++) {
  103.            jstep = next + (istep * direction);
  104.            while (jstep < rotate_lo)  jstep += rotate_size;
  105.            while (jstep > rotate_max) jstep -= rotate_size;
  106.            if (++incr > fstep) {    /* time to randomize */
  107.           incr = 1;
  108.                   fstep = ((fsteps[fkey-1]* (rand15() >> 8)) >> 6) + 1;
  109.           fromred   = dacbox[last][0];
  110.           fromgreen = dacbox[last][1];
  111.           fromblue  = dacbox[last][2];
  112.                   tored     = rand15() >> 9;
  113.                   togreen   = rand15() >> 9;
  114.                   toblue    = rand15() >> 9;
  115.           }
  116.            dacbox[jstep][0] = fromred   + (((tored     - fromred  )*incr)/fstep);
  117.            dacbox[jstep][1] = fromgreen + (((togreen - fromgreen)*incr)/fstep);
  118.            dacbox[jstep][2] = fromblue  + (((toblue  - fromblue )*incr)/fstep);
  119.            }
  120.         }
  121.      if (step >= rotate_size) step = oldstep;
  122.      spindac(direction, step);
  123.      }
  124.       if (step >= rotate_size) step = oldstep;
  125.       kbdchar = getakey();
  126.       if (paused && (kbdchar != ' ' && kbdchar != 'c' && kbdchar != 'C' ))
  127.      paused = 0;            /* clear paused condition    */
  128.       switch (kbdchar) {
  129.      case '+':                      /* '+' means rotate forward     */
  130.          case RIGHT_ARROW:              /* RightArrow = rotate fwd      */
  131.         fkey = 0;
  132.         direction = 1;
  133.         last = rotate_max;
  134.         next = rotate_lo;
  135.         incr = 999;
  136.         break;
  137.      case '-':                      /* '-' means rotate backward    */
  138.          case LEFT_ARROW:               /* LeftArrow = rotate bkwd      */
  139.         fkey = 0;
  140.         direction = -1;
  141.         last = rotate_lo;
  142.         next = rotate_max;
  143.         incr = 999;
  144.         break;
  145.          case UP_ARROW:                 /* UpArrow means speed up       */
  146.         daclearn = 1;
  147.         if (++daccount >= colors) --daccount;
  148.         break;
  149.          case DOWN_ARROW:               /* DownArrow means slow down    */
  150.         daclearn = 1;
  151.         if (daccount > 1) daccount--;
  152.         break;
  153.      case '1':
  154.      case '2':
  155.      case '3':
  156.      case '4':
  157.      case '5':
  158.      case '6':
  159.      case '7':
  160.      case '8':
  161.      case '9':
  162.         step = kbdchar - '0';   /* change step-size */
  163.         if (step > rotate_size) step = rotate_size;
  164.         break;
  165.          case F1:                       /* F1 - F10:                    */
  166.          case F2:                       /* select a shading factor      */
  167.          case F3:
  168.          case F4:
  169.          case F5:
  170.          case F6:
  171.          case F7:
  172.          case F8:
  173.          case F9:
  174.          case F10:
  175. #ifndef XFRACT
  176.             fkey = kbdchar-1058;
  177. #else
  178.             switch (kbdchar) {
  179.                case F1:
  180.                   fkey = 1;break;
  181.                case F2:
  182.                   fkey = 2;break;
  183.                case F3:
  184.                   fkey = 3;break;
  185.                case F4:
  186.                   fkey = 4;break;
  187.                case F5:
  188.                   fkey = 5;break;
  189.                case F6:
  190.                   fkey = 6;break;
  191.                case F7:
  192.                   fkey = 7;break;
  193.                case F8:
  194.                   fkey = 8;break;
  195.                case F9:
  196.                   fkey = 9;break;
  197.                case F10:
  198.                   fkey = 10;break;
  199.             }
  200. #endif
  201.         if (reallyega) fkey = (fkey+1)>>1; /* limit on EGA */
  202.         fstep = 1;
  203.         incr = 999;
  204.         break;
  205.          case ENTER:                    /* enter key: randomize all colors */
  206.          case ENTER_2:                  /* also the Numeric-Keypad Enter */
  207.             fkey = rand15()/3277 + 1;
  208.         if (reallyega)        /* limit on EGAs */
  209.            fkey = (fkey+1)>>1;
  210.         fstep = 1;
  211.         incr = 999;
  212.         oldstep = step;
  213.         step = rotate_size;
  214.         break;
  215.      case 'r':                      /* color changes */
  216.         if (changecolor    == -1) changecolor = 0;
  217.      case 'g':                      /* color changes */
  218.         if (changecolor    == -1) changecolor = 1;
  219.      case 'b':                      /* color changes */
  220.         if (changecolor    == -1) changecolor = 2;
  221.         if (changedirection == 0) changedirection = -1;
  222.      case 'R':                      /* color changes */
  223.         if (changecolor    == -1) changecolor = 0;
  224.      case 'G':                      /* color changes */
  225.         if (changecolor    == -1) changecolor = 1;
  226.      case 'B':                      /* color changes */
  227.         if (dotmode == 11) break;
  228.         if (changecolor    == -1) changecolor = 2;
  229.         if (changedirection == 0) changedirection = 1;
  230.         if (reallyega) break;    /* no sense on real EGAs */
  231.         for (i = 1; i < 256; i++) {
  232.            dacbox[i][changecolor] += changedirection;
  233.            if (dacbox[i][changecolor] == 64)
  234.            dacbox[i][changecolor] = 63;
  235.            if (dacbox[i][changecolor] == 255)
  236.           dacbox[i][changecolor] = 0;
  237.            }
  238.         changecolor    = -1;    /* clear flags for next time */
  239.         changedirection = 0;
  240.         paused        = 0;    /* clear any pause */
  241.      case ' ':                      /* use the spacebar as a "pause" toggle */
  242.      case 'c':                      /* for completeness' sake, the 'c' too */
  243.      case 'C':
  244.         pauserotate();        /* pause */
  245.         break;
  246.      case '>':            /* single-step */
  247.      case '.':
  248.      case '<':
  249.      case ',':
  250.         if (kbdchar == '>' || kbdchar == '.') {
  251.            direction = 1;
  252.            last = rotate_max;
  253.            next = rotate_lo;
  254.            incr = 999;
  255.            }
  256.         else {
  257.            direction = -1;
  258.            last = rotate_lo;
  259.            next = rotate_max;
  260.            incr = 999;
  261.            }
  262.         fkey = 0;
  263.         spindac(direction,1);
  264.         if (! paused)
  265.            pauserotate();        /* pause */
  266.         break;
  267.      case 'd':                      /* load colors from "default.map" */
  268.      case 'D':
  269.         if (ValidateLuts("default") != 0)
  270.            break;
  271.         fkey = 0;            /* disable random generation */
  272.         pauserotate();        /* update palette and pause */
  273.         break;
  274.      case 'a':                      /* load colors from "altern.map" */
  275.      case 'A':
  276.         if (ValidateLuts("altern") != 0)
  277.            break;
  278.         fkey = 0;            /* disable random generation */
  279.         pauserotate();        /* update palette and pause */
  280.         break;
  281.      case 'l':                      /* load colors from a specified map */
  282. #ifndef XFRACT /* L is used for RIGHT_ARROW in Unix keyboard mapping */
  283.      case 'L':
  284. #endif
  285.         load_palette();
  286.         fkey = 0;            /* disable random generation */
  287.         pauserotate();        /* update palette and pause */
  288.         break;
  289.      case 's':                      /* save the palette */
  290.      case 'S':
  291.         save_palette();
  292.         fkey = 0;            /* disable random generation */
  293.         pauserotate();        /* update palette and pause */
  294.         break;
  295.          case ESC:                      /* escape */
  296.         more = 0;            /* time to bail out */
  297.         break;
  298.      default:            /* maybe a new palette */
  299.         if (reallyega) break;    /* no sense on real EGAs */
  300.         fkey = 0;            /* disable random generation */
  301.         if (kbdchar == 1084) set_palette(Black, White);
  302.         if (kbdchar == SF2) set_palette(Red, Yellow);
  303.         if (kbdchar == SF3) set_palette(Blue, Green);
  304.         if (kbdchar == SF4) set_palette(Black, Yellow);
  305.         if (kbdchar == SF5) set_palette(Black, Red);
  306.         if (kbdchar == SF6) set_palette(Black, Blue);
  307.         if (kbdchar == SF7) set_palette(Black, Green);
  308.         if (kbdchar == SF8) set_palette(Blue, Yellow);
  309.         if (kbdchar == SF9) set_palette(Red, Green);
  310.         if (kbdchar == 1093) set_palette(Green, White);
  311.         if (kbdchar == 1094) set_palette2(Black, White);
  312.         if (kbdchar == 1095) set_palette2(Red, Yellow);
  313.         if (kbdchar == 1096) set_palette2(Blue, Green);
  314.         if (kbdchar == 1097) set_palette2(Black, Yellow);
  315.         if (kbdchar == 1098) set_palette2(Black, Red);
  316.         if (kbdchar == 1099) set_palette2(Black, Blue);
  317.         if (kbdchar == 1100) set_palette2(Black, Green);
  318.         if (kbdchar == 1101) set_palette2(Blue, Yellow);
  319.         if (kbdchar == 1102) set_palette2(Red, Green);
  320.         if (kbdchar == 1103) set_palette2(Green, White);
  321.         if (kbdchar == 1104) set_palette3(Blue, Green, Red);
  322.         if (kbdchar == 1105) set_palette3(Blue, Yellow, Red);
  323.         if (kbdchar == 1106) set_palette3(Red, White, Blue);
  324.         if (kbdchar == 1107) set_palette3(Red, Yellow, White);
  325.         if (kbdchar == 1108) set_palette3(Black, Brown, Yellow);
  326.         if (kbdchar == 1109) set_palette3(Blue, Brown, Green);
  327.         if (kbdchar == 1110) set_palette3(Blue, Green, Green);
  328.         if (kbdchar == 1111) set_palette3(Blue, Green, White);
  329.         if (kbdchar == 1112) set_palette3(Green, Green, White);
  330.         if (kbdchar == 1113) set_palette3(Red, Blue, White);
  331.         pauserotate();  /* update palette and pause */
  332.         break;
  333.      }
  334.       }
  335.  
  336.    helpmode = oldhelpmode;        /* return to previous help mode */
  337.    EXIT_OVLY;
  338. }
  339.  
  340. static void pauserotate()        /* pause-the-rotate routine */
  341. {
  342. int olddaccount;            /* saved dac-count value goes here */
  343. BYTE olddac0,olddac1,olddac2;
  344.  
  345.    if (paused)                /* if already paused , just clear */
  346.       paused = 0;
  347.    else {                /* else set border, wait for a key */
  348.       olddaccount = daccount;
  349.       olddac0 = dacbox[0][0];
  350.       olddac1 = dacbox[0][1];
  351.       olddac2 = dacbox[0][2];
  352.       daccount = 256;
  353.       dacbox[0][0] = 48;
  354.       dacbox[0][1] = 48;
  355.       dacbox[0][2] = 48;
  356.       spindac(0,1);            /* show white border */
  357.       if (dotmode == 11)
  358.          dvid_status(100," Paused in \"color cycling\" mode ");
  359. #ifndef XFRACT
  360.       while (!keypressed());          /* wait for any key */
  361. #else
  362.       waitkeypressed(0);                /* wait for any key */
  363. #endif
  364.       if (dotmode == 11)
  365.      dvid_status(0,"");
  366.       dacbox[0][0] = olddac0;
  367.       dacbox[0][1] = olddac1;
  368.       dacbox[0][2] = olddac2;
  369.       spindac(0,1);            /* show black border */
  370.       daccount = olddaccount;
  371.       paused = 1;
  372.       }
  373. }
  374.  
  375. static void set_palette(start, finish)
  376. BYTE start[3], finish[3];
  377. {
  378.    int i, j;
  379.    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  380.    for(i=1;i<=255;i++)            /* fill the palette    */
  381.       for (j = 0; j < 3; j++)
  382.      dacbox[i][j] = (i*start[j] + (256-i)*finish[j])/255;
  383. }
  384.  
  385. static void set_palette2(start, finish)
  386. BYTE start[3], finish[3];
  387. {
  388.    int i, j;
  389.    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  390.    for(i=1;i<=128;i++)
  391.       for (j = 0; j < 3; j++) {
  392.      dacbox[i][j]      = (i*finish[j] + (128-i)*start[j] )/128;
  393.      dacbox[i+127][j] = (i*start[j]  + (128-i)*finish[j])/128;
  394.       }
  395. }
  396.  
  397. static void set_palette3(start, middle, finish)
  398. BYTE start[3], middle[3], finish[3];
  399. {
  400.    int i, j;
  401.    dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  402.    for(i=1;i<=85;i++)
  403.       for (j = 0; j < 3; j++) {
  404.      dacbox[i][j]      = (i*middle[j] + (86-i)*start[j] )/85;
  405.      dacbox[i+85][j]  = (i*finish[j] + (86-i)*middle[j])/85;
  406.      dacbox[i+170][j] = (i*start[j]  + (86-i)*finish[j])/85;
  407.       }
  408. }
  409.  
  410.  
  411. void save_palette()
  412. {
  413.    FILE *dacfile;
  414.    int i,oldhelpmode;
  415.    oldhelpmode = helpmode;
  416.    stackscreen();
  417.    temp1[0] = 0;
  418.    helpmode = HELPCOLORMAP;
  419.    i = field_prompt(0,"Name of map file to write",NULL,temp1,60,NULL);
  420.    unstackscreen();
  421.    if (i != -1 && temp1[0]) {
  422.       if (strchr(temp1,'.') == NULL)
  423.      strcat(temp1,".map");
  424.       dacfile = fopen(temp1,"w");
  425.       if (dacfile == NULL)
  426.      buzzer(2);
  427.       else {
  428. #ifndef XFRACT
  429.      for (i = 0; i < colors; i++)
  430. #else
  431.      for (i = 0; i < 256; i++)
  432. #endif
  433.         fprintf(dacfile, "%3d %3d %3d\n",
  434.             dacbox[i][0] << 2,
  435.             dacbox[i][1] << 2,
  436.             dacbox[i][2] << 2);
  437.      memcpy(olddacbox,dacbox,256*3);
  438.      colorstate = 2;
  439.      strcpy(colorfile,temp1);
  440.      }
  441.       fclose(dacfile);
  442.       }
  443.    helpmode = oldhelpmode;
  444. }
  445.  
  446.  
  447. void load_palette(void)
  448. {
  449.    int i,oldhelpmode;
  450.    char filename[80];
  451.    oldhelpmode = helpmode;
  452.    strcpy(filename,colorfile);
  453.    stackscreen();
  454.    helpmode = HELPCOLORMAP;
  455.    i = getafilename("Select a MAP File",mapmask,filename);
  456.    unstackscreen();
  457.    if (i >= 0)
  458.       if (ValidateLuts(filename) == 0)
  459.      memcpy(olddacbox,dacbox,256*3);
  460.    helpmode = oldhelpmode;
  461. }
  462.  
  463.  
  464.